home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / MacTCP Library 1.1 / ShowMyAddress ƒ / Main.c < prev    next >
Text File  |  1995-12-04  |  22KB  |  991 lines
  1. /*
  2.     main.c
  3.     
  4.     Main code for ShowMyAddress.  This is just a simple program that will display
  5.     a Mac's IP address (& possibly it's name?) in a small window.
  6.     
  7.     History:
  8.         06/15/95 dn - Created.
  9.         12/04/95 dn - Updated for Apprentice 4
  10. */
  11.  
  12. // System Includes
  13. #include <MyTCPIncludes.h>
  14.  
  15. #include <Sound.h>
  16. #include <Icons.h>
  17.  
  18. // Local Includes
  19. #include "Main.h"
  20.  
  21. Boolean gQuit,gResolverDone;
  22. short gMacTCP;
  23.  
  24. IPAddr gOurAddr;
  25. Str255 gOurAddrStr="\punknown";
  26. Str255 gOurIPStr="\p0.0.0.0";
  27.  
  28. short _gXLoc;
  29.  
  30. short gXPos,gYPos;
  31.  
  32. AEEventHandlerUPP gOappUpp,gOdocUpp,gPdocUpp,gQuitUpp;
  33.  
  34. Handle gErrSnd;
  35. SoundUPP gErrUpp;
  36.  
  37. char* gAboutTxt[]={
  38.     "© 1995 by Dave Nebinger.",
  39.     "Some portions © Symantec and Apple.",
  40.     " ",
  41.     "Just a simple program to show how to",
  42.     "get a Mac's IP address and cannonical",
  43.     "name using my MacTCP library.",
  44.     " ",
  45.     NULL
  46. };
  47.  
  48.  
  49. // Main Code Entry Point
  50. void main(void){
  51.     OSErr err;
  52.     
  53.     err=InitToolbox();
  54.     
  55.     if (err==noErr){
  56.         err=Initialize();
  57.         
  58.         if (err==noErr){
  59.             err=MainLoop();
  60.         }
  61.         
  62.         err=CleanUp();
  63.     }
  64. }
  65.  
  66. // appleevents.h
  67. OSErr InitializeAppleEvents(void){
  68.     OSErr err=noErr;
  69.     
  70.     gOappUpp=NewAEEventHandlerProc(HandleOApp);
  71.     gOdocUpp=NewAEEventHandlerProc(HandleODoc);
  72.     gPdocUpp=NewAEEventHandlerProc(HandlePDoc);
  73.     gQuitUpp=NewAEEventHandlerProc(HandleQuit);
  74.     
  75.     err=AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,gOappUpp, 0, FALSE);
  76.     
  77.     if (err!=noErr)
  78.         return err;
  79.     
  80.     err=AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,gOdocUpp, 0, FALSE);
  81.     
  82.     if (err!=noErr)
  83.         return err;
  84.     
  85.     err=AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,gPdocUpp, 0, FALSE);
  86.     
  87.     if (err!=noErr)
  88.         return err;
  89.     
  90.     err=AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,gQuitUpp, 0, FALSE);
  91.     
  92.     return err;
  93. }
  94.  
  95. pascal OSErr HandleOApp(AppleEvent* ae,AppleEvent* reply,long refCon){
  96.     OSErr err=noErr;
  97.     
  98.     err=HandleRequiredParams(ae);
  99.     
  100.     if (err==noErr){
  101.         // do any open application stuff here.
  102.         
  103.         // nothing to do, it has been done in the initialization routines...
  104.     } else
  105.         HandleMissedParams(reply);
  106.     
  107.     return err;
  108. }
  109.  
  110. pascal OSErr HandleODoc(AppleEvent* ae,AppleEvent* reply,long refCon){
  111.     OSErr err=noErr;
  112.     
  113.     err=HandleRequiredParams(ae);
  114.     
  115.     if (err==noErr){
  116.         // do any open document stuff here...
  117.         err=NotHandledEvent(reply);
  118.         
  119.     }
  120.     
  121.     return err;
  122. }
  123.  
  124. OSErr NotHandledEvent(AppleEvent* ae){
  125.     OSErr err;
  126.     
  127.     if (ae->dataHandle!=nil){
  128.         Str255 errStr="\pShowMyAddress can't process the event";
  129.         
  130.         err=AEPutParamPtr(ae,keyErrorString,typeChar,(Ptr)&errStr[1],errStr[0]);
  131.     }
  132.     
  133.     return errAEEventNotHandled;
  134. }
  135.  
  136. OSErr HandleMissedParams(AppleEvent* ae){
  137.     OSErr err=noErr;
  138.     
  139.     if (ae->dataHandle!=nil){
  140.         Str255 errStr="\pRequired parameters were not received";
  141.         
  142.         err=AEPutParamPtr(ae,keyErrorString,typeChar,(Ptr)&errStr[1],errStr[0]);
  143.     }
  144.     
  145.     return err;
  146. }
  147.  
  148. pascal OSErr HandlePDoc(AppleEvent* ae,AppleEvent* reply,long refCon){
  149.     OSErr err=noErr;
  150.     
  151.     err=HandleRequiredParams(ae);
  152.     
  153.     if (err==noErr){
  154.         // do any print document stuff here
  155.         err=NotHandledEvent(reply);
  156.     } else
  157.         HandleMissedParams(reply);
  158.     
  159.     return err;
  160. }
  161.  
  162. pascal OSErr HandleQuit(AppleEvent* ae,AppleEvent* reply,long refCon){
  163.     OSErr err=noErr;
  164.     
  165.     err=HandleRequiredParams(ae);
  166.     
  167.     if (err==noErr){
  168.         // do any error free quit stuff here.
  169.     } else
  170.         HandleMissedParams(reply);
  171.     
  172.     gQuit=true;
  173.     
  174.     return noErr; // force to noErr because we don't care about errors...
  175. }
  176.  
  177. OSErr HandleRequiredParams(AppleEvent* ae){
  178.     DescType type;
  179.     Size size;
  180.     OSErr err;
  181.  
  182.     err=AEGetAttributePtr(ae, keyMissedKeywordAttr,typeWildCard, &type,nil, 0, &size);
  183.  
  184.     if (err==errAEDescNotFound){    // you got all the required parameters
  185.         err=noErr;
  186.     } else {
  187.         if (err == noErr)          // you missed a required parameter
  188.             err=errAEParamMissed;
  189.         // else the call to AEGetAttributePtr failed
  190.     }
  191.     
  192.     return err;
  193. }
  194.  
  195. OSErr Initialize(void){
  196.     OSErr err=noErr,serr;
  197.     Handle mbar;
  198.     MenuHandle mh;
  199.     
  200.     // Initialize our application...
  201.     
  202.     // init the globals
  203.     gQuit=false;
  204.     gMacTCP=-1;
  205.     gOurAddr.a.addr=(b_32)0L;
  206.     _gXLoc=0; // internal value for controlling where strings are drawn...
  207.     
  208.     gXPos=20;
  209.     gYPos=50;
  210.     
  211.     // install our menu bar
  212.     mbar=GetNewMBar(kMBar);
  213.     SetMenuBar(mbar);
  214.     DrawMenuBar();
  215.     mh=GetMHandle(kMApple);
  216.     AddResMenu(mh,'DRVR');
  217.     
  218.     // get and install the error sound...
  219.     gErrSnd=GetResource('snd ',30006);
  220.     gErrUpp=NewSoundProc(HandleErrorSound);
  221.     
  222.     if (gErrSnd!=(Handle)0L){
  223.         // detach it to keep it around
  224.         DetachResource(gErrSnd);
  225.         MoveHHi(gErrSnd);
  226.         
  227.         ErrorSound(gErrUpp);
  228.     }
  229.     
  230.     // Initialize the apple events...
  231.     err=InitializeAppleEvents();
  232.     
  233.     // Initialize TCP & DNR
  234.     err=OpenMacTCP(&gMacTCP,false);
  235.     
  236.     if (err==noErr){
  237.         
  238.         // pass null to use the "Hosts" file in the system folder
  239.         err=OpenResolver((StringPtr)NULL);
  240.         
  241.         if (err==noErr){
  242.             // Have the resolver, now get our address...
  243.             GetAddrParamBlock* ip;
  244.             
  245.             ip=NewGetIPParmBlkPtr();
  246.             
  247.             ip->ioCRefNum=gMacTCP; // the TCP driver refnum global...
  248.             
  249.             // get our ip address
  250.             err=GetMyIPAddr(ip,FALSE); // do it sync...
  251.             
  252.             if (err!=noErr){
  253.                 // Sometimes it can return an error, but it can be ignored
  254.                 // if the ioResult field for the IP parm block is noErr.
  255.                 // check the ioResult to be sure...
  256.                 err=ip->ioResult;
  257.             }
  258.             
  259.             if (err==noErr){
  260.                 HostInfoUPP hiupp;
  261.                 HostInfo hinfo;
  262.                 
  263.                 // set our address now
  264.                 gOurAddr.a.addr=ip->ourAddress;
  265.                 
  266.                 // convert it to a string...
  267.                 AddrToStr(ip->ourAddress,(char*)gOurIPStr);
  268.                 c2pstr((char*)gOurIPStr);
  269.                 
  270.                 // we have our address, now get our string address...
  271.                 
  272.                 gResolverDone=false;
  273.                 hiupp=NewHostInfoProc(ResolverDone);
  274.                 
  275.                 err=AddrToName(ip->ourAddress,&hinfo,hiupp,(char*)0);
  276.                 
  277.                 if (err==cacheFault){
  278.                     // then the resolver is checking with the name server, must wait
  279.                     // for the reply...
  280.                     
  281.                     if (!gResolverDone){
  282.                         while (!gResolverDone){
  283.                             /* Do Nothing Here */
  284.                             ;
  285.                         }
  286.                     }
  287.                 }
  288.                 
  289.                 // we are now done with the AddrToName call...
  290.                 DisposeHostInfoProc(hiupp);
  291.                 
  292.                 if (hinfo.rtnCode==(long)noErr){
  293.                     // no error fetching the name, use it...
  294.                     c2pstr(hinfo.cname);
  295.                     BlockMoveData((Ptr)hinfo.cname,(Ptr)gOurAddrStr,hinfo.cname[0]MenuEnabling();
  296.             ms=MenuSelect(lpt);
  297.             err=HandleMenu(ms);
  298.             break;
  299.         case inDesk:
  300.         case inSysWindow:
  301.             SystemClick(erp,wind);
  302.             break;
  303.         case inContent:
  304.             SelectWindow(wind);
  305.             break;
  306.         case inDrag:
  307.             {
  308.                 Rect br;
  309.                 
  310.                 BlockMoveData((Ptr)(&qd.screenBits.bounds),(Ptr)&br,sizeof(Rect));
  311.                 
  312.                 InsetRect(&br,4,4);
  313.                 
  314.                 DragWindow(wind,pt,&br);
  315.             }
  316.             break;
  317.         case inGoAway:
  318.             // we shouldn't get these...
  319.             DisposeWindow(wind);
  320.             break;
  321.         case inZoomIn:
  322.         case inZoomOut:
  323.             {
  324.                 Boolean sel=true;
  325.                 
  326.                 if (erp->modifiers & cmdKey)
  327.                     sel=false; // don't select if the cmd key is down
  328.                 
  329.                 ZoomWindow(wind,part,sel);
  330.             }
  331.             break;
  332.         default:
  333.             // some weird part was clicked
  334.             // we ignore it...
  335.             break;
  336.     }
  337.     
  338.     return err;
  339. }
  340.  
  341. OSErr HandleMenuEnabling(void){
  342.     OSErr err=noErr;
  343.     WindowPtr wind;
  344.     Boolean closeEnabled=true;
  345.     MenuHandle mh;
  346.     
  347.     wind=FrontWindow();
  348.     
  349.     mh=GetMHandle(kMFile);
  350.     
  351.     if (wind==(WindowPtr)0L){
  352.         // there are no active windows to close
  353.         DisableItem(mh,kMClose);
  354.         
  355.         // reset the window offsets to start at the upper-left position on the screen
  356.         
  357.         gXPos=20;
  358.         gYPos=50;
  359.         
  360.     } else {
  361.         // there are active windows to close
  362.         EnableItem(mh,kMClose);
  363.     }
  364.     
  365.     return err;
  366. }
  367.  
  368. OSErr HandleMenu(long ms){
  369.     OSErr err=noErr;
  370.     short menu,item;
  371.     
  372.     menu=HiWord(ms);
  373.     item=LoWord(ms);
  374.     
  375.     if (menu!=0){
  376.         // a valid menu choice
  377.         switch (menu){
  378.             case kMApple:
  379.                 err=HandleApple(item);
  380.                 break;
  381.             case kMFile:
  382.                 err=HandleFile(item);
  383.                 break;
  384.             case kMEdit:
  385.                 err=HandleEdit(item);
  386.                 break;
  387.             default:
  388.                 // could be an error, but I am ignoring them...
  389.                 break;
  390.         }
  391.     } else {
  392.         ms=MenuChoice();
  393.         
  394.         // ms represents a disabled choice the user picked.
  395.     }
  396.     
  397.     HiliteMenu(0);
  398.     
  399.     return err;
  400. }
  401.  
  402. pascal void HandleErrorSound(short var){
  403.     if (var!=0){
  404.         HLock(gErrSnd);
  405.         
  406.         // play the sound synchronously...
  407.         (void)SndPlay((SndChannelPtr)0L,(SndListHandle)gErrSnd,FALSE);
  408.         
  409.         HUnlock(gErrSnd);
  410.     }
  411. }
  412.  
  413. OSErr HandleError(StringPtr errStr,OSErr err){
  414.     OSErr ierr=noErr;
  415.     Str255 numErr;
  416.     long lerr;
  417.     
  418.     // build the error number string
  419.     lerr=(long)err;
  420.     NumToString(lerr,numErr);
  421.     
  422.     // have paramtext fill in the alert
  423.     ParamText(errStr,numErr,"\p","\p");
  424.     
  425.     // let stopalert display the error message.
  426.     StopAlert(30006,(ModalFilterUPP)0L);
  427.     
  428.     return ierr;
  429. }
  430.  
  431. OSErr HandleApple(short item){
  432.     OSErr err=noErr;
  433.     
  434.     switch (item){
  435.         case kMAbout:
  436.             err=HandleAbout();
  437.             break;
  438.         default:
  439.             // handle da's here
  440.             {
  441.                 MenuHandle mh=GetMHandle(kMApple);
  442.                 Str255 da;
  443.                 GrafPtr savePort;
  444.                 
  445.                 GetItem(mh,item,da);
  446.                 
  447.                 GetPort(&savePort);
  448.                 
  449.                 OpenDeskAcc(da);
  450.                 
  451.                 SetPort(savePort);
  452.             }
  453.             break;
  454.     }
  455.     
  456.     return err;
  457. }
  458.  
  459. OSErr HandleFile(short item){
  460.     OSErr err=noErr;
  461.     
  462.     switch (item){
  463.         case kMNew:
  464.             err=NewSAWindow();
  465.             break;
  466.         case kMOpen:
  467.             // we shouldn't get one of these...
  468.             break;
  469.         case kMClose:
  470.             {
  471.                 WindowPtr wind;
  472.                 WindowPeek wp;
  473.                 WindowPtr next;
  474.                 
  475.                 wind=FrontWindow();
  476.                 
  477.                 if (wind!=(WindowPtr)0L){
  478.                     wp=(WindowPeek)wind;
  479.                     
  480.                     next=(WindowPtr)wp->nextWindow;
  481.                     
  482.                     if (wp->windowKind<0){
  483.                         // a desk acc window
  484.                         CloseDeskAcc(wp->windowKind);
  485.                     } else {
  486.                         // a regular window
  487.                         DisposeWindow(wind);
  488.                     }
  489.                     
  490.                     if (next!=(WindowPtr)0L)
  491.                         SelectWindow(next);
  492.                 }
  493.             }
  494.             break;
  495.         case kMQuit:
  496.             gQuit=true;
  497.             break;
  498.         default:
  499.             break;
  500.     }
  501.     
  502.     return err;
  503. }
  504.  
  505. OSErr HandleEdit(short item){
  506.     OSErr err=noErr;
  507.     
  508.     // This application doesn't use any editing features so they
  509.     // are being ignored...
  510.     
  511.     return err;
  512. }
  513.  
  514. // use this routine to handle key events.
  515. OSErr HandleKey(EventRecord* erp){
  516.     OSErr err=noErr;
  517.     char ch,key;
  518.     long mk;
  519.     
  520.     ch=erp->message&charCodeMask;
  521.     key=(erp->message&keyCodeMask)>>8;
  522.     
  523.     if (erp->modifiers & cmdKey){
  524.         // menu event
  525.         err=HandleMenuEnabling();
  526.         mk=MenuKey(ch);
  527.         err=HandleMenu(mk);
  528.     } else {
  529.         // normal key events
  530.         
  531.         // currently ignored
  532.     }
  533.     
  534.     return err;
  535. }
  536.  
  537. // Handle window activate events here
  538. OSErr HandleActivateEvt(EventRecord* erp){
  539.     OSErr err=noErr;
  540.     WindowPtr wind;
  541.     
  542.     wind=(WindowPtr)erp->message;
  543.     
  544.     if (wind==(WindowPtr)0L)
  545.         return noErr;
  546.     
  547.     if (erp->modifiers&activeFlag){
  548.         BringToFront(wind); // make it the frontmost
  549.         HiliteWindow(wind,true); // activate the window...
  550.     } else {
  551.         HiliteWindow(wind,false); // deactivate the window...
  552.     }
  553.     
  554.     return err;
  555. }
  556.  
  557. // Handle Window Updates
  558. OSErr HandleUpdate(EventRecord* erp){
  559.     OSErr err=noErr;
  560.     WindowPtr wind;
  561.     
  562.     wind=(WindowPtr)erp->message;
  563.     
  564.     BeginUpdate(wind);
  565.     DrawSAWindow(wind);
  566.     EndUpdate(wind);
  567.     
  568.     return err;
  569. }
  570.  
  571. // Handle Disk Events here...
  572. OSErr HandleDisk(EventRecord* erp){
  573.     OSErr err=noErr;
  574.     Point pt;
  575.     
  576.     SetPt(&pt,100,100);
  577.     err=(OSErr)DIBadMount(pt,erp->message);
  578.     
  579.     return err;
  580. }
  581.  
  582. // Entry point for Apple Event Handling
  583. OSErr HandleHighLevelEvent(EventRecord* erp){
  584.     OSErr err=noErr;
  585.     
  586.     err=AEProcessAppleEvent(erp);
  587.     
  588.     return err;
  589. }
  590.  
  591. // use this routine to handle activate events...
  592. OSErr HandleActivate(EventRecord* erp){
  593.     OSErr err=noErr;
  594.     WindowPtr wind;
  595.     
  596.     wind=FrontWindow();
  597.     if (wind!=(WindowPtr)0L)
  598.         HiliteWindow(wind,true); // hilite the window
  599.     
  600.     return err;
  601. }
  602.  
  603. // use this routine to handle the deactivate events
  604. OSErr HandleDeactivate(EventRecord* erp){
  605.     OSErr err=noErr;
  606.     WindowPtr wind;
  607.     
  608.     wind=FrontWindow();
  609.     if (wind!=(WindowPtr)0L)
  610.         HiliteWindow(wind,false); // deactivate the window
  611.     
  612.     return err;
  613. }
  614.  
  615. // use this routine to change the mouse cursor depending on where the mouse is located.
  616. OSErr HandleMouseMoved(EventRecord* erp){
  617.     OSErr err=noErr;
  618.     
  619.     return err;
  620. }
  621.  
  622. // Get and display a new ShowAddressWindow
  623. OSErr NewSAWindow(void){
  624.     OSErr err=noErr;
  625.     WindowPtr wind;
  626.     short wwid,whei;
  627.     
  628.     wind=GetNewCWindow(kWWindow,kWindNoStorage,kWindInFront);
  629.     
  630.     if (wind!=(WindowPtr)0L){
  631.         // move the window into it's new position...
  632.         MoveWindow(wind,gXPos,gYPos,true);
  633.         ShowWindow(wind);
  634.         
  635.         wwid=wind->portRect.right-wind->portRect.left;
  636.         whei=wind->portRect.bottom-wind->portRect.top;
  637.         
  638.         gXPos+=15;
  639.         gYPos+=30;
  640.         
  641.         if (gXPos+wwid+10>qd.screenBits.bounds.right){
  642.             gXPos=20;
  643.             gYPos=50;
  644.         }
  645.         
  646.         if (gYPos+whei+10>qd.screenBits.bounds.bottom)
  647.             gYPos=50;
  648.         
  649.         err=DrawSAWindow(wind);
  650.     } else {
  651.         err=ResError();
  652.     }
  653.     
  654.     return err;
  655. }
  656.  
  657. OSErr DrawSAWindow(WindowPtr wind){
  658.     OSErr err=noErr;
  659.     GrafPtr savePort;
  660.     
  661.     if (wind!=(WindowPtr)0L){
  662.         // set the port to the new window (just to be sure)...
  663.         GetPort(&savePort);
  664.         
  665.         SetPort((GrafPtr)wind);
  666.         
  667.         // now set up the font stuff
  668.         TextFont(geneva);
  669.         TextFace(normal);
  670.         TextSize(9);
  671.         TextMode(srcOr);
  672.         
  673.         TextFace(bold);
  674.         MoveTo(5,13);
  675.         DrawString("\pIP Address:");
  676.         MoveTo(5,26);
  677.         DrawString("\pCanonical Name:");
  678.         
  679.         if (_gXLoc==0)    // calculate _gXLoc once given the current font, size, and face...
  680.             _gXLoc=5+StringWidth("\pCanonical Name:") + 6;
  681.         
  682.         TextFace(normal);
  683.         MoveTo(_gXLoc,13);
  684.         DrawString(gOurIPStr);
  685.         MoveTo(_gXLoc,26);
  686.         DrawString(gOurAddrStr);
  687.         
  688.         SetPort(savePort);
  689.     }
  690.     
  691.     return err;
  692. }
  693.  
  694. // Initialize the Mac Toolbox
  695. OSErr InitToolbox(void){
  696.     OSErr err=noErr;
  697.     
  698.     InitGraf((Ptr) &qd.thePort);
  699.     InitFonts();
  700.     InitWindows();
  701.     InitMenus();
  702.     FlushEvents(everyEvent,0);
  703.     TEInit();
  704.     InitDialogs(0L);
  705.     InitCursor();
  706.     
  707.     return err;
  708. }
  709.  
  710. OSErr HandleAbout(void){
  711.     OSErr err=noErr;
  712.     DialogPtr dlg;
  713.     short i;
  714.     Rect r;
  715.     Handle h;
  716.     UserItemUPP frame,icons,box,txt;
  717.     ModalFilterUPP custom;
  718.     GrafPtr savePort;
  719.     short itemHit;
  720.     
  721.     GetPort(&savePort);
  722.     
  723.     dlg=GetNewDialog(128,kWindNoStorage,kWindInFront);
  724.     if (dlg!=(DialogPtr)0L){
  725.         // use the dialog
  726.         
  727.         SetPort((GrafPtr)dlg);
  728.         
  729.         // first frame the ok button...
  730.         GetDItem(dlg,5,&i,&h,&r);        
  731.         frame=NewUserItemProc(ItemOvalFrame);
  732.         SetDItem(dlg,5,i,(Handle)frame,&r);
  733.         
  734.         // now do the icon family...
  735.         GetDItem(dlg,2,&i,&h,&r);
  736.         icons=NewUserItemProc(ItemIconFamily);
  737.         SetDItem(dlg,2,i,(Handle)icons,&r);
  738.         
  739.         // and the 3d outline
  740.         GetDItem(dlg,3,&i,&h,&r);
  741.         box=NewUserItemProc(Item3DBox);
  742.         SetDItem(dlg,3,i,(Handle)box,&r);
  743.         
  744.         // and the text
  745.         GetDItem(dlg,4,&i,&h,&r);
  746.         txt=NewUserItemProc(ItemAboutText);
  747.         SetDItem(dlg,4,i,(Handle)txt,&r);
  748.         
  749.         itemHit=3;
  750.         
  751.         custom=NewModalFilterProc(CustomFilter);
  752.         
  753.         ShowWindow((WindowPtr)dlg);
  754.         
  755.         while (itemHit!=1){ // while not the ok button
  756.             ModalDialog(custom,&itemHit);
  757.             
  758.             switch (itemHit){
  759.                 case 2: // icon family
  760.                     // play the beavis sound...
  761.                     break;
  762.                 default:
  763.                     // do nothing special
  764.                     break;
  765.             }
  766.         }
  767.         
  768.         DisposeDialog(dlg);
  769.         
  770.         DisposeRoutineDescriptor(custom);
  771.         DisposeRoutineDescriptor(frame);
  772.         DisposeRoutineDescriptor(icons);
  773.         DisposeRoutineDescriptor(txt);
  774.         DisposeRoutineDescriptor(box);
  775.     } else {
  776.         err=ResError();
  777.     }
  778.     
  779.     SetPort(savePort);
  780.     
  781.     return err;
  782. }
  783.  
  784. pascal void ItemOvalFrame(WindowPtr wind,short item){
  785.     DialogPtr dlg;
  786.     short i;
  787.     Rect r;
  788.     Handle h;
  789.     
  790.     dlg=(DialogPtr)wind;
  791.     
  792.     GetDItem(dlg,item,&i,&h,&r);
  793.     
  794.     PenSize(2,2);
  795.     
  796.     FrameRoundRect(&r,8,8);
  797.     
  798.     PenNormal();
  799. }
  800.  
  801. pascal void ItemAboutText(WindowPtr wind,short item){
  802.     DialogPtr dlg;
  803.     short i;
  804.     Rect r;
  805.     Handle h;
  806.     short sw;
  807.     short hz,w,x,y,z;
  808.     RgnHandle clip;
  809.     register char* cp;
  810.     char** cpp;
  811.     short slen;
  812.     
  813.     clip=NewRgn();
  814.     GetClip(clip);
  815.     
  816.     dlg=(DialogPtr)wind;
  817.     
  818.     GetDItem(dlg,item,&i,&h,&r);
  819.     
  820.     // first draw the header
  821.     TextFont(times);
  822.     TextFace(normal);
  823.     TextSize(14);
  824.     
  825.     sw=StringWidth("\pShowMyAddress");
  826.     
  827.     w=(r.right-r.left); // width of the text box
  828.     hz=(r.bottom-r.top);// height of the text box
  829.     
  830.     MoveTo(r.left+(w/2)-(sw/2),18+r.top);
  831.     DrawString("\pShowMyAddress");
  832.     
  833.     r.top+=20;
  834.     ClipRect(&r);
  835.     
  836.     z=0;
  837.     cpp=gAboutTxt;
  838.     
  839.     TextFont(geneva);
  840.     TextSize(9);
  841.     TextFace(normal);
  842.     
  843.     while (*cpp!=NULL){
  844.         // calculate the length of the text
  845.         slen=0;
  846.         cp=*cpp;
  847.         
  848.         while (*cp){
  849.             cp++;
  850.             slen++;
  851.         }
  852.         
  853.         MoveTo(r.left+2,r.top+(12*(z+1)));
  854.         DrawText(*cpp,0,slen);
  855.         
  856.         cpp++;
  857.         z++;
  858.     }
  859.     
  860.     SetClip(clip);
  861.     DisposeRgn(clip);
  862. }
  863.  
  864. #define kDarkValue 10000
  865. #define kLightValue 63000
  866.  
  867. pascal void Item3DBox(WindowPtr wind,short item){
  868.     DialogPtr dlg;
  869.     short i;
  870.     Rect r;
  871.     Handle h;
  872.     RGBColor ltg,dkg;
  873.     RGBColor save;
  874.     
  875.     GetForeColor(&save);
  876.     
  877.     dlg=(DialogPtr)wind;
  878.     
  879.     GetDItem(dlg,item,&i,&h,&r);
  880.     
  881.     PenNormal();
  882.     
  883.     PenSize(2,2);
  884.     
  885.     ltg.red=kLightValue;
  886.     ltg.green=kLightValue;
  887.     ltg.blue=kLightValue;
  888.     
  889.     dkg.red=kDarkValue;
  890.     dkg.green=kDarkValue;
  891.     dkg.blue=kDarkValue;
  892.     
  893.     RGBForeColor(<g);
  894.     MoveTo(r.left,r.bottom);
  895.     LineTo(r.left,r.top);
  896.     LineTo(r.right,r.top);
  897.     
  898.     RGBForeColor(&dkg);
  899.     LineTo(r.right,r.bottom);
  900.     LineTo(r.left+2,r.bottom);
  901.     
  902.     PenNormal();
  903.     
  904.     RGBForeColor(&save);
  905. }
  906.  
  907. pascal void ItemIconFamily(WindowPtr wind,short item){
  908.     DialogPtr dlg;
  909.     short i;
  910.     Rect r;
  911.     Handle h;
  912.     
  913.     dlg=(DialogPtr)wind;
  914.     
  915.     GetDItem(dlg,item,&i,&h,&r);
  916.     
  917.     PlotIconID(&r,atVerticalCenter+atHorizontalCenter,ttNone,128);
  918. }
  919.  
  920. pascal Boolean CustomFilter(DialogPtr dlg,EventRecord* erp,short* item){
  921.     Boolean hand=false;
  922.     GrafPtr saved;
  923.     short part;
  924.     
  925.     GetPort(&saved);
  926.     SetPort((GrafPtr)dlg);
  927.     
  928.     switch (erp->what){
  929.         case keyDown:
  930.         case autoKey:
  931.             switch ((erp->message)&charCodeMask){
  932.                 case 0x0d: // return key
  933.                 case 0x03: // enter key
  934.                 case 0x1b: // escape key
  935.                     *item=1;
  936.                     hand=true;
  937.                     break;
  938.                 case 'c':
  939.                 case 'C':
  940.                 case 'o':
  941.                 case 'O':
  942.                 case 'w':
  943.                 case 'W': // look for the command key...
  944.                     if (erp->modifiers&cmdKey){
  945.                         // hit command-w
  946.                         *item=1;
  947.                         hand=true;
  948.                     }
  949.                     break;
  950.             }
  951.             break;
  952.         case mouseDown:
  953.             HandleLimitedMouse(erp,&part,&hand);
  954.             
  955.             break;
  956.         case updateEvt:
  957.             {
  958.                 WindowPtr wind=(WindowPtr)erp->message;
  959.                 
  960.                 if ((wind!=(WindowPtr)0)&&((DialogPtr)(wind)!=dlg)){
  961.                     // got an update event for a background window!
  962.                     
  963.                     // By calling BeginUpdate/EndUpdate, the update events will stop coming to us.
  964.                     
  965.                     BeginUpdate(wind);
  966.                     
  967.                     // call the window's drawing procedure here...
  968.                     DrawSAWindow(wind);
  969.                     
  970.                     EndUpdate(wind);
  971.                 }
  972.             }
  973.             break;
  974.             
  975.         default:
  976.             // do nothing special
  977.             break;
  978.     }
  979.     
  980.     SetPort(saved);
  981.     
  982.     return hand;
  983. }
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990.  
  991.